COMMENT ⊗   VALID 00003 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	REAL PROCEDURE SEARCH(REFERENCE INTEGER PIC1MAP,PIC2MAP
C00009 00003	PROCEDURE FINDIN(REFERENCE INTEGER PICMAP INTEGER WINDOWSIZE 
C00013 ENDMK
C⊗;
REAL PROCEDURE SEARCH(REFERENCE INTEGER PIC1MAP,PIC2MAP;
		      INTEGER WINDOWSIZE;
		      REFERENCE REAL POSY,POSX;
		      REAL DY1(0),DX1(0),DY2(1),DX2(1) );

COMMENT applies the binary search correlation method to find a window
        centered about POSX,POSY in PIC1 (defined to be 0 to 1 in X and Y),
	and of size WINDOWSIZE pixels square in the whole of PIC2. PIC1MAP
	and PIC2MAP are an array of starting addresses of successively
	reduced versions of the pictures. The best match in PIC2 is returned
	in POSX and POSY, the value of the match (0 to 1) is the value of SEARCH.
        The search can be constrained to the rectangle bounded by DY1,DX1,
	DY2,DX2 (all 0 to 1) if desired;

   BEGIN
   INTEGER IL,JL,IH,JH,WID,HIG,NORD,I,J,K,L,M,N;   REAL QUAL;
   REAL PXF,PYF;
   INTEGER ILT,JLT,IHT,JHT,
           ILS,JLS,IHS,JHS,
           ISC,JSC,ITC,JTC,
           ISS,JSS,ITS,JTS;
   REAL QUALT,PXFT,PYFT;

   BOOLEAN PROCEDURE TRYRED(INTEGER MS,MT);
      BEGIN
      BOOLEAN ANS;
      ANS←FALSE;
      IF QUALT<.8 THEN
         BEGIN
         REAL PXFTT,PYFTT,QUALTT,QUATTT;
         INTEGER WISH; BOOLEAN LOSE;

         OUTSTR(CVS(MS)&":"&CVS(MT)&" ");

         ISC←(ISS←MEMORY[MEMORY[LOCATION(PIC1MAP)+MS]+PCLN])*POSY;
         JSC←(JSS←MEMORY[MEMORY[LOCATION(PIC1MAP)+MS]+LNBY])*POSX;
         ITC←(ITS←MEMORY[MEMORY[LOCATION(PIC2MAP)+MT]+PCLN])*PYF;
         JTC←(JTS←MEMORY[MEMORY[LOCATION(PIC2MAP)+MT]+LNBY])*PXF;

         WISH←WINDOWSIZE; QUALTT←0;
         DO
            BEGIN
            LOSE←TRUE;
            WISH←WISH%2;

            JLS←JSC-WISH;
            ILS←ISC-WISH;
            JHS←JSC+WISH;
            IHS←ISC+WISH;

            JLT←(JTC-WINDOWSIZE) MAX (JTS*DX1-WISH-1);
            ILT←(ITC-WINDOWSIZE) MAX (ITS*DY1-WISH-1);
            JHT←(JTC+WINDOWSIZE) MIN (JTS*DX2+WISH+1);
            IHT←(ITC+WINDOWSIZE) MIN (ITS*DY2+WISH+1);

            OUTSTR("["&CVS(JLS)&":"&CVS(JHS)&","&CVS(ILS)&":"&CVS(IHS)&"]ε");
            OUTSTR("["&CVS(JLT)&":"&CVS(JHT)&","&CVS(ILT)&":"&CVS(IHT)&"]→");

            QUATTT←NORCOR(MEMORY[MEMORY[LOCATION(PIC1MAP)+MS]],ILS,JLS,IHS,JHS,
                          MEMORY[MEMORY[LOCATION(PIC2MAP)+MT]],ILT,JLT,IHT,JHT);

            OUTSTR("["&CVS(JLT)&":"&CVS(JHT)&","&CVS(ILT)&":"&CVS(IHT)&"]"
                   &CVF(QUATTT)&" ");
            IF QUATTT>QUALTT THEN
               BEGIN
               PXFTT←0.5*(JLT+JHT)/JTS;
               PYFTT←0.5*(ILT+IHT)/ITS;
               QUALTT←QUATTT;
               LOSE←FALSE;
               END;
            END
         UNTIL QUALTT≥.65 ∨ WISH≤1 ∨ LOSE;
         SETFORMAT(0,3);
         OUTSTR(CVF(QUALT)&" TO"&CVF(QUALTT));
         IF QUALTT>QUALT THEN
            BEGIN
            OUTSTR("→("&CVF(PXFTT)&","&
                   CVF(PYFTT)&") ");
            QUALT←QUALTT;
            PXFT←PXFTT;
            PYFT←PYFTT;
            ANS←TRUE;
            END;
         OUTSTR('15&'12);
         RETURN(ANS);
         END;
      END;

   IF DX1>DX2 THEN DX1↔DX2;
   IF DY1>DY2 THEN DY1↔DY2;
   IF DX1≥1∨DX2≤0∨DY1≥1∨DY2≤0 THEN RETURN(0);
   DX1←DX1 MAX 0; DX2←DX2 MIN 1; DY1←DY1 MAX 0; DY2←DY2 MIN 1;

   WID←MEMORY[PIC1MAP+LNBY]*ABS(DX2-DX1);
   HIG←MEMORY[PIC1MAP+PCLN]*ABS(DY2-DY1);
   NORD←0;
   WHILE WINDOWSIZE≤(WID MIN HIG)/2↑(NORD+1) DO NORD←NORD+1;

   OUTSTR("FINAL PICTURE IS "&
      CVS(MEMORY[MEMORY[LOCATION(PIC1MAP)+NORD]+LNBY])&" BY "&
      CVS(MEMORY[MEMORY[LOCATION(PIC1MAP)+NORD]+PCLN])&'15&'12);

   PXF←(DX1+DX2)/2; PYF←(DY1+DY2)/2;
   QUAL←1;

   FOR M←NORD STEP -1 UNTIL 0 DO
      BEGIN
      QUALT←-1.0;

                   IF TRYRED(   M,   M)    THEN
      IF M≤3 THEN  IF TRYRED(   M,-M-1)    THEN
      IF M≤2 THEN  IF TRYRED(-M-1, M+1)    THEN
      IF M≤1 THEN     TRYRED(   M, M+1)       ;

      OUTSTR('15&'12);

      PXF←PXFT;
      PYF←PYFT;

      QUAL←QUAL MIN QUALT;
      END;

   POSX←PXF; POSY←PYF;
   RETURN(QUAL);
   END;
PROCEDURE FINDIN(REFERENCE INTEGER PICMAP; INTEGER WINDOWSIZE; 
                 REFERENCE INTEGER NFS; REFERENCE REAL FY,FX);

   BEGIN
   INTEGER IORD,HIG,WID,IW;
   IORD←0; WHILE (WINDOWSIZE ASH -(IORD+1))≥2 DO IORD←IORD+1;
   IW←WINDOWSIZE ASH -IORD;
   
   HIG←MEMORY[MEMORY[LOCATION(PICMAP)+IORD]+PCLN];
   WID←MEMORY[MEMORY[LOCATION(PICMAP)+IORD]+LNBY];

      BEGIN
      INTEGER IAV,I,J,K,AH,AW,FHAV;
      INTEGER ARRAY INTER[-2:AH←(HIG-1)%IW-1,
                           0:AW←(WID-1)%IW-1];
      REAL ARRAY FXV,FYV,FIV[1:NFS];
      IAV←INTRST(MEMORY[MEMORY[LOCATION(PICMAP)+IORD]],IW,INTER[0,0]);

      FHAV←0;

      FOR I←0 STEP 1 UNTIL AH DO
      FOR J←0 STEP 1 UNTIL AW DO
      IF (INTER[I,J] LAND 1)≠1∧INTER[I,J]>IAV%8 THEN
         BEGIN
         REAL FXT,FYT,FIT;
         INTEGER L,H,M;
         FYT←((I+.5)*IW+.5)/HIG;
         FXT←((J+.5)*IW+.5)/WID;
         FIT←INTER[I,J];

         L←1; H←FHAV;
         WHILE L≤H DO IF FIT>FIV[M←(L+H)%2] THEN H←M-1 ELSE L←M+1;
         FHAV←(FHAV+1) MIN NFS;
         IF L≤FHAV THEN
            BEGIN
            FOR M←FHAV-1 STEP -1 UNTIL L DO
               BEGIN
               FXV[M+1]←FXV[M]; FYV[M+1]←FYV[M]; FIV[M+1]←FIV[M];
               END;
            FXV[L]←FXT; FYV[L]←FYT; FIV[L]←FIT;
            END;
         END;
      FOR I←1 STEP 1 UNTIL FHAV DO
         BEGIN
         OUTSTR(CVF(FIV[I])&" ("&CVF(FXV[I])&","&CVF(FYV[I])&")"&'15&'12);
         MEMORY[LOCATION(FX)-1+I,REAL]←FXV[I];
         MEMORY[LOCATION(FY)-1+I,REAL]←FYV[I];
         END;
      NFS←FHAV;
      END;

   END;